import axios from 'axios'
import { v4 as uuidv4 } from 'uuid'

// 调试环境变量
function logEnvironmentVariables() {
  console.log('===== 环境变量调试信息 =====')
  if (import.meta && import.meta.env) {
    console.log('Vite环境变量:')
    console.log('- VITE_APP_AI_API_KEY:', import.meta.env.VITE_APP_AI_API_KEY ? '已设置' : '未设置')
    console.log('- VITE_AI_API_KEY:', import.meta.env.VITE_AI_API_KEY ? '已设置' : '未设置')
    console.log('- VITE_DEEPSEEK_API_KEY:', import.meta.env.VITE_DEEPSEEK_API_KEY ? '已设置' : '未设置')
    console.log('- VITE_VOLCANO_API_KEY:', import.meta.env.VITE_VOLCANO_API_KEY ? '已设置' : '未设置')
    console.log('- VITE_AI_API_URL:', import.meta.env.VITE_AI_API_URL ? '已设置' : '未设置')
    console.log('- VITE_DEEPSEEK_API_URL:', import.meta.env.VITE_DEEPSEEK_API_URL ? '已设置' : '未设置')
    console.log('- VITE_VOLCANO_API_URL:', import.meta.env.VITE_VOLCANO_API_URL ? '已设置' : '未设置')
  } else {
    console.log('非Vite环境或import.meta.env不可用')
  }
  
  if (window) {
    console.log('Window环境变量:')
    console.log('- VUE_APP_AI_API_KEY:', window.VUE_APP_AI_API_KEY ? '已设置' : '未设置')
    console.log('- VUE_APP_DEEPSEEK_API_KEY:', window.VUE_APP_DEEPSEEK_API_KEY ? '已设置' : '未设置')
    console.log('- VUE_APP_VOLCANO_API_KEY:', window.VUE_APP_VOLCANO_API_KEY ? '已设置' : '未设置')
    console.log('- AI_API_KEY:', window.AI_API_KEY ? '已设置' : '未设置')
    console.log('- VUE_APP_AI_API_URL:', window.VUE_APP_AI_API_URL ? '已设置' : '未设置')
    console.log('- VUE_APP_DEEPSEEK_API_URL:', window.VUE_APP_DEEPSEEK_API_URL ? '已设置' : '未设置')
    console.log('- VUE_APP_VOLCANO_API_URL:', window.VUE_APP_VOLCANO_API_URL ? '已设置' : '未设置')
  }
  console.log('===========================')
}

// 尝试记录环境变量信息
try {
  logEnvironmentVariables()
} catch (error) {
  console.error('环境变量日志记录失败:', error)
}

// 配置不同模型的API信息
const API_CONFIGS = {
  deepseek: {
    url: (
      // Vite环境变量
      (import.meta && import.meta.env && (
        import.meta.env.VITE_DEEPSEEK_API_URL ||
        import.meta.env.VITE_AI_API_URL
      )) ||
      // Vue CLI环境变量
      (window && (
        window.VUE_APP_DEEPSEEK_API_URL ||
        window.VUE_APP_AI_API_URL
      )) ||
      // 默认API URL
      'https://api.deepseek.com/chat/completions'
    ),
    key: (
      // Vite环境变量
      (import.meta && import.meta.env && (
        import.meta.env.VITE_DEEPSEEK_API_KEY ||
        import.meta.env.VITE_AI_API_KEY
      )) ||
      // Vue CLI环境变量
      (window && (
        window.VUE_APP_DEEPSEEK_API_KEY ||
        window.VUE_APP_AI_API_KEY ||
        window.AI_API_KEY
      )) ||
      ''
    ),
    model: 'deepseek-chat'
  },
  volcano: {
    url: (
      // Vite环境变量
      (import.meta && import.meta.env && import.meta.env.VITE_VOLCANO_API_URL) ||
      // Vue CLI环境变量
      (window && window.VUE_APP_VOLCANO_API_URL) ||
      // 默认API URL
      'https://api.volcengine.com/ml/api/v1/services/aigc'
    ),
    key: (
      // Vite环境变量
      (import.meta && import.meta.env && import.meta.env.VITE_VOLCANO_API_KEY) ||
      // Vue CLI环境变量
      (window && window.VUE_APP_VOLCANO_API_KEY) ||
      ''
    ),
    model: 'doubao-1-5-lite-32k-250115'
  }
}

// 原始API配置保留向后兼容性
const API_URL = API_CONFIGS.deepseek.url
const API_KEY = API_CONFIGS.deepseek.key

// 调试信息
console.log('DeepSeek API URL:', API_CONFIGS.deepseek.url)
console.log('DeepSeek API密钥状态:', API_CONFIGS.deepseek.key ? '已配置' : '未配置')
console.log('火山引擎 API URL:', API_CONFIGS.volcano.url)
console.log('火山引擎 API密钥状态:', API_CONFIGS.volcano.key ? '已配置' : '未配置')

export const nameService = {
  async generateNames(userInput, generationMethod = null) {
    console.log('生成名字，用户输入:', userInput);
    
    // 统一处理userInput中的多胞胎信息
    const processedInput = { ...userInput };
    
    // 如果是多胞胎，设置births值为多胞胎数量
    if (processedInput.isMultipleBirth && processedInput.multipleCount > 1) {
      processedInput.births = processedInput.multipleCount;
    } else {
      processedInput.births = 1;
    }
    
    // 确保gender字段与genders[0]保持一致（兼容旧逻辑）
    if (processedInput.genders && processedInput.genders.length > 0) {
      processedInput.gender = processedInput.genders[0] === '男' ? 'male' : 'female';
    }
    
    // 设置默认生成方法信息
    if (generationMethod) {
      generationMethod.isLocal = false;
      generationMethod.modelType = processedInput.modelType || 'deepseek';
    }
    
    // 如果用户选择本地生成，则直接使用本地逻辑
    if (processedInput.modelType === 'local') {
      console.log('使用本地逻辑生成名字');
      if (generationMethod) {
        generationMethod.isLocal = true;
        generationMethod.modelType = 'local';
      }
      return this.generateNamesLocally(processedInput);
    }
    
    try {
      // 检查是否有对应的API密钥
      const apiKey = this.getApiKeyForModel(processedInput.modelType);
      
      if (!apiKey) {
        console.warn(`未配置${processedInput.modelType}的API密钥，使用本地逻辑生成名字`);
        if (generationMethod) {
          generationMethod.isLocal = true;
          generationMethod.modelType = 'local';
        }
        return this.generateNamesLocally(processedInput);
      }
      
      // 根据选择的模型调用不同的API
      let response;
      if (processedInput.modelType === 'volcano') {
        response = await this.callVolcanoAPI(processedInput, apiKey);
      } else {
        // 默认使用DeepSeek API
        response = await this.callDeepSeekAPI(processedInput, apiKey);
      }
      
      // 处理API响应
      if (!response.ok) {
        console.error('API请求失败:', response.status, response.statusText);
        if (generationMethod) {
          generationMethod.isLocal = true;
          generationMethod.modelType = 'local';
        }
        return this.generateNamesLocally(processedInput);
      }
      
      const data = await response.json();
      
      // 使用统一的解析函数处理不同模型的响应
      const parsedResponse = this.parseModelResponse(data, processedInput.modelType);
      
      // 格式化响应为名字列表
      const formattedNames = this.formatAIResponse(parsedResponse, processedInput);
      
      if (formattedNames.length > 0) {
        console.log('成功从AI获取名字:', formattedNames.length);
        return formattedNames;
      } else {
        console.warn('API返回的数据无法解析为有效名字，使用本地逻辑生成名字');
        if (generationMethod) {
          generationMethod.isLocal = true;
          generationMethod.modelType = 'local';
        }
        return this.generateNamesLocally(processedInput);
      }
    } catch (error) {
      console.error('调用API生成名字时出错:', error);
      if (generationMethod) {
        generationMethod.isLocal = true;
        generationMethod.modelType = 'local';
      }
      return this.generateNamesLocally(processedInput);
    }
  },
  
  // 根据模型类型获取API密钥
  getApiKeyForModel(modelType) {
    switch (modelType) {
      case 'deepseek':
        return import.meta.env.VITE_DEEPSEEK_API_KEY;
      case 'volcano':
        return import.meta.env.VITE_VOLCANO_API_KEY;
      default:
        return null;
    }
  },
  
  // 调用火山大模型API
  async callVolcanoAPI(userInput, apiKey) {
    const prompt = this.generateVolcanoPrompt(userInput);
    
    const apiEndpoint = import.meta.env.VITE_VOLCANO_API_URL || 'https://api.volcengine.com/v1/llm/generation';
    const modelName = import.meta.env.VITE_VOLCANO_MODEL || 'doubao-1-5-lite-32k-250115';
    
    const requestBody = {
      model: modelName,
      messages: [
        {
          role: 'user',
          content: prompt
        }
      ],
      temperature: 0.7,
      max_tokens: 3600
    };
    
    return fetch(apiEndpoint, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${apiKey}`
      },
      body: JSON.stringify(requestBody)
    });
  },
  
  // 为火山大模型生成提示词
  generateVolcanoPrompt(userInput) {
    const { gender, births, nameLength, surname, avoidWords } = userInput;
    
    let promptText = `请为一个${this.getGenderText(gender)}婴儿生成${nameLength === '3' ? '三个字' : '两个字'}的中文名字，包含姓氏，`;
    
    if (births > 1) {
      promptText += `这是${this.getBirthsText(births)}，需要生成${births}个名字，`;
    }
    
    promptText += `姓氏是"${surname}"，`;
    
    if (avoidWords && avoidWords.trim() !== '') {
      promptText += `名字中请避免使用以下字符: ${avoidWords}，`;
    }
    
    promptText += '请按以下格式返回数据：\n';
    promptText += '[\n';
    promptText += '  {"name": "名字1的名（不包含姓氏）", "meaning": "名字含义简短解释"},\n';
    promptText += '  {"name": "名字2的名（不包含姓氏）", "meaning": "名字含义简短解释"},\n';
    promptText += '  ...\n';
    promptText += ']\n';
    promptText += '只返回JSON数据，不要有其他解释文字。确保每个名字的长度为' + (nameLength === '3' ? '3' : '2') + '个字，不包含姓氏。';
    
    return promptText;
  },
  
  // 解析火山大模型的响应
  parseVolcanoResponse(responseData) {
    console.log('解析火山大模型返回数据:', typeof responseData, responseData);
    
    try {
      let content = '';
      
      // 检查是否是新的响应结构："choices"数组
      if (responseData && responseData.choices && responseData.choices.length > 0 && 
          responseData.choices[0].message && responseData.choices[0].message.content) {
        content = responseData.choices[0].message.content;
        console.log('从choices中提取content:', content);
      } 
      // 检查旧的响应结构
      else if (responseData && responseData.response) {
        content = responseData.response;
        console.log('从response字段提取content:', content);
      } else {
        console.error('未知的火山大模型响应格式');
        return [];
      }
      
      // 尝试提取和修复JSON
      let jsonResults = [];
      try {
        // 尝试直接解析
        jsonResults = JSON.parse(content);
        console.log('成功解析JSON，获取到', jsonResults.length, '个名字组');
      } catch (error) {
        console.error('直接解析失败，尝试修复JSON:', error);
        
        // 尝试从内容中提取有效的JSON数组
        content = this.repairIncompleteJson(content);
        
        try {
          jsonResults = JSON.parse(content);
          console.log('修复后成功解析JSON，获取到', jsonResults.length, '个名字组');
        } catch (e) {
          console.error('修复后解析仍然失败，尝试提取单个JSON对象:', e);
          jsonResults = this.extractJsonObjects(content);
          console.log('从文本中提取了', jsonResults.length, '个JSON对象');
        }
      }
      
      return jsonResults;
    } catch (error) {
      console.error('解析火山大模型响应出错:', error);
      return [];
    }
  },

  // 修复不完整的JSON
  repairIncompleteJson(jsonString) {
    // 如果JSON已经被截断，尝试修复
    if (!jsonString) return '[]';
    
    console.log('开始修复不完整的JSON');
    let fixedJson = jsonString;
    
    // 计算开括号和闭括号的数量
    const openBrackets = (jsonString.match(/\[/g) || []).length;
    const closeBrackets = (jsonString.match(/\]/g) || []).length;
    const openBraces = (jsonString.match(/\{/g) || []).length;
    const closeBraces = (jsonString.match(/\}/g) || []).length;
    
    console.log(`括号统计 - 开方括号: ${openBrackets}, 闭方括号: ${closeBrackets}, 开花括号: ${openBraces}, 闭花括号: ${closeBraces}`);
    
    // 如果有未闭合的方括号，添加闭合方括号
    for (let i = 0; i < openBrackets - closeBrackets; i++) {
      fixedJson += ']';
    }
    
    // 如果有未闭合的花括号，添加闭合花括号
    for (let i = 0; i < openBraces - closeBraces; i++) {
      fixedJson += '}';
    }
    
    // 检查是否有未闭合的字符串引号
    const quoteCount = (fixedJson.match(/"/g) || []).length;
    if (quoteCount % 2 !== 0) {
      fixedJson += '"';
    }
    
    console.log('修复后的JSON:', fixedJson);
    return fixedJson;
  },

  // 从文本中提取JSON对象
  extractJsonObjects(text) {
    if (!text) return [];
    
    const results = [];
    
    // 尝试匹配完整的JSON对象模式
    const fullNamePattern = /"fullNames"\s*:\s*\[\s*\{\s*"name"\s*:\s*"[^"]+"\s*,\s*"gender"\s*:\s*"[^"]+"\s*\}(?:\s*,\s*\{\s*"name"\s*:\s*"[^"]+"\s*,\s*"gender"\s*:\s*"[^"]+"\s*\})*\s*\]/g;
    let match;
    
    // 尝试提取包含fullNames的对象
    const fullObjectPattern = /\{\s*"fullNames"\s*:[\s\S]*?(?:\}\s*,|\}\s*$)/g;
    while ((match = fullObjectPattern.exec(text)) !== null) {
      try {
        // 尝试修复和解析提取的对象
        let objText = match[0];
        if (objText.endsWith(',')) {
          objText = objText.slice(0, -1);
        }
        
        // 确保对象是闭合的
        if (!objText.trim().endsWith('}')) {
          objText += '}';
        }
        
        const parsed = JSON.parse(objText);
        results.push(parsed);
      } catch (e) {
        console.warn('无法解析提取的对象:', e.message);
      }
    }
    
    // 如果没有找到完整对象，尝试匹配单个名字
    if (results.length === 0) {
      const namePattern = /"name"\s*:\s*"([^"]+)"\s*,\s*"gender"\s*:\s*"([^"]+)"/g;
      const names = [];
      
      while ((match = namePattern.exec(text)) !== null) {
        names.push({
          name: match[1],
          gender: match[2]
        });
      }
      
      if (names.length > 0) {
        // 构建一个包含提取名字的对象
        results.push({
          fullNames: names,
          meaning: "名字含义未提供",
          relationMeaning: "关联含义未提供",
          wuxing: "五行未提供",
          zodiac: "生肖信息未提供",
          phonetics: "音韵未提供",
          structure: "字形结构未提供"
        });
      }
    }
    
    return results;
  },
  
  // 解析DeepSeek API的响应
  parseDeepSeekResponse(responseData) {
    try {
      console.log('解析DeepSeek响应，原始数据类型:', 
        typeof responseData === 'object' ? 'object' : typeof responseData);
          
      // DeepSeek的响应格式有两种可能:
      // 1. { text: "..." } 
      // 2. { choices: [{ message: { content: "..." } }] }
      let content = '';
      
      if (responseData.choices && Array.isArray(responseData.choices) && responseData.choices.length > 0) {
        // OpenAI兼容格式
        if (responseData.choices[0]?.message?.content) {
          content = responseData.choices[0].message.content;
          console.log('从choices结构提取内容成功，长度:', content.length);
        } else {
          console.warn('DeepSeek响应中未找到content字段');
          return [];
        }
      } else if (responseData.text) {
        // 直接返回文本格式
        content = responseData.text;
        console.log('从text字段提取内容成功，长度:', content.length);
      } else {
        console.warn('未识别的DeepSeek响应格式:', JSON.stringify(responseData).substring(0, 300) + '...');
        return [];
      }
      
      console.log('提取到的内容:', content.substring(0, 100) + '...');
      
      // 尝试解析完整JSON
      try {
        // 尝试直接解析完整JSON
        const parsedJson = JSON.parse(content);
        console.log('成功解析DeepSeek返回的完整JSON数据，包含', parsedJson.length, '个名字');
        return parsedJson;
      } catch (jsonError) {
        console.warn('无法直接解析JSON，尝试查找JSON数组并修复:', jsonError.message);
        
        // 尝试从文本中提取JSON数组
        const jsonMatch = content.match(/\[\s*\{.*?(?:\}\s*\]|$)/s);
        
        if (!jsonMatch) {
          console.warn('无法从响应中匹配到JSON数组');
          return [];
        }
        
        let jsonStr = jsonMatch[0];
        
        // 检查JSON是否不完整（可能由于token限制被截断）
        const openCurly = (jsonStr.match(/\{/g) || []).length;
        const closeCurly = (jsonStr.match(/\}/g) || []).length;
        const openBrackets = (jsonStr.match(/\[/g) || []).length;
        const closeBrackets = (jsonStr.match(/\]/g) || []).length;
        
        console.log(`检测到JSON结构: { 开: ${openCurly}, 闭: ${closeCurly} }, [ 开: ${openBrackets}, 闭: ${closeBrackets} ]`);
        
        // 修复不完整的JSON
        if (openCurly > closeCurly || openBrackets > closeBrackets) {
          console.warn('JSON不完整，尝试修复');
          
          // 确保数组结束
          if (!jsonStr.trim().endsWith(']')) {
            // 关闭最后可能未闭合的对象
            while (openCurly > closeCurly) {
              jsonStr += '}';
              closeCurly++;
            }
            
            // 关闭数组
            if (openBrackets > closeBrackets) {
              jsonStr += ']';
            }
          }
          
          console.log('修复后的JSON:', jsonStr.substring(0, 100) + '...');
        }
        
        try {
          const parsedJson = JSON.parse(jsonStr);
          console.log('修复后成功解析JSON，包含', parsedJson.length, '个名字');
          return parsedJson;
        } catch (fixedJsonError) {
          console.error('修复后仍无法解析JSON:', fixedJsonError.message);
          
          // 进一步尝试提取各个独立对象
          const objMatches = content.match(/\{\s*"fullNames"[\s\S]*?\}/g) || content.match(/\{\s*"name"[\s\S]*?\}/g);
          if (objMatches && objMatches.length > 0) {
            console.log('提取到', objMatches.length, '个独立对象');
            try {
              // 构建一个新的数组
              const constructedArray = '[' + objMatches.join(',') + ']';
              const parsedJson = JSON.parse(constructedArray);
              console.log('使用独立对象构建JSON成功，包含', parsedJson.length, '个名字');
              return parsedJson;
            } catch (constructError) {
              console.error('构建JSON失败:', constructError.message);
            }
          }
          
          return [];
        }
      }
    } catch (error) {
      console.error('解析DeepSeek API响应时出错:', error);
      return [];
    }
  },

  async generateNamesFromAI(userInput, apiConfig) {
    try {
      const apiKey = apiConfig.key
      const apiUrl = apiConfig.url
      const model = apiConfig.model
      
      // 检查API密钥是否配置
      if (!apiKey) {
        console.error('未配置API密钥，无法使用AI生成名字')
        throw new Error('未配置API密钥')
      }
      
      // 检查API URL是否有效
      if (!apiUrl) {
        console.error('未配置API URL，无法使用AI生成名字')
        throw new Error('未配置API URL')
      }
      
      const prompt = this.buildPrompt(userInput)
      console.log('使用API URL:', apiUrl)
      console.log('使用模型:', model)
      console.log('发送到AI的提示词:', prompt)
      
      // 根据不同的API构建不同的请求数据
      let requestData, headers
      
      if (apiConfig === API_CONFIGS.volcano) {
        // 火山引擎API请求格式
        requestData = {
          model: model,
          messages: [
            {
              role: 'system',
              content: '你是一个专业的中国传统起名专家，精通五行、生肖、诗词、国学等传统文化知识。请根据用户提供的信息，生成符合要求的名字及详细解释。'
            },
            {
              role: 'user',
              content: prompt
            }
          ],
          parameters: {
            temperature: 0.7,
            max_tokens: 2000
          }
        }
        
        headers = {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${apiKey}`
        }
      } else {
        // DeepSeek或其他兼容OpenAI接口的API请求格式
        requestData = {
          model: model,
          messages: [
            {
              role: 'system',
              content: '你是一个专业的中国传统起名专家，精通五行、生肖、诗词、国学等传统文化知识。请根据用户提供的信息，生成符合要求的名字及详细解释。'
            },
            {
              role: 'user',
              content: prompt
            }
          ],
          temperature: 0.7,
          max_tokens: 2000
        }
        
        headers = {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${apiKey}`
        }
      }
      
      console.log('正在发送API请求...')
      
      // 发送API请求
      const response = await axios.post(apiUrl, requestData, { headers })
      
      console.log('收到API响应:', response.status)
      
      // 检查API响应是否有效
      if (!response.data) {
        console.error('API响应无效:', response)
        throw new Error('API响应无效')
      }
      
      // 解析AI返回的响应
      const parsedResponse = this.parseResponse(response.data)
      
      // 检查解析后的响应是否有效
      if (!parsedResponse || !Array.isArray(parsedResponse) || parsedResponse.length === 0) {
        console.error('解析后的响应无效:', parsedResponse)
        throw new Error('解析后的响应无效')
      }
      
      console.log('成功解析API响应，获得名字数量:', parsedResponse.length)
      
      // 将AI生成的结果转换为应用所需的数据结构
      const formattedNames = this.formatAIResponse(parsedResponse, userInput)
      
      // 如果格式化后没有名字，则使用本地生成
      if (!formattedNames || formattedNames.length === 0) {
        console.warn('AI响应格式化后没有有效名字，切换到本地生成')
        return this.generateFallbackNames(userInput)
      }
      
      return formattedNames
    } catch (error) {
      // 详细记录错误信息
      console.error('AI生成名字失败:', error)
      if (error.response) {
        // 服务器响应了错误状态码
        console.error('API错误响应:', error.response.status, error.response.data)
      } else if (error.request) {
        // 请求已发送但未收到响应
        console.error('未收到API响应:', error.request)
      }
      // 重新抛出错误，让调用函数处理
      throw error
    }
  },
  
  // 格式化AI响应
  formatAIResponse(aiResponse, userInput) {
    console.log('开始格式化AI响应，原始数据:', JSON.stringify(aiResponse).substring(0, 500) + '...')
    
    try {
      // 确保aiResponse是一个数组且不为空
      if (!Array.isArray(aiResponse) || aiResponse.length === 0) {
        console.error('AI响应格式无效，不是一个数组或为空')
        throw new Error('AI响应格式无效')
      }
      
      const names = []
      const nameLength = userInput.nameLength || '2' // 获取名字长度参数
      
      // 处理AI返回的名字数据
      for (let i = 0; i < Math.min(aiResponse.length, 10); i++) {
        const nameData = aiResponse[i]
        
        // 记录每个名字对象的结构以便调试
        console.log(`处理名字数据[${i}]:`, JSON.stringify(nameData).substring(0, 200) + '...')
        
        const babyNames = []
        
        // 如果是多胞胎场景，尝试从对象中提取多个名字
        if (userInput.isMultipleBirth) {
          if (nameData.fullNames && Array.isArray(nameData.fullNames)) {
            // 直接使用AI返回的多个名字
            for (let j = 0; j < userInput.multipleCount; j++) {
              // 如果AI返回的名字足够
              if (j < nameData.fullNames.length) {
                // 尝试多种可能的格式提取名字
                let babyName = '';
                const nameEntry = nameData.fullNames[j];
                
                if (typeof nameEntry === 'string') {
                  babyName = nameEntry;
                } else if (nameEntry) {
                  // 按优先级依次检查可能的属性
                  babyName = nameEntry.fullName || nameEntry.name || '';
                }
                
                // 确保姓氏正确
                const fullName = babyName.startsWith(userInput.surname) ? 
                  babyName : 
                  userInput.surname + babyName;
                
                const gender = userInput.genders[j] || '男';
                babyNames.push({
                  fullName: fullName,
                  gender: gender,
                  babyIndex: j
                });
              } else {
                // 如果AI返回的名字不足，使用默认名
                const gender = userInput.genders[j] || '男';
                const defaultName = this.generateDefaultNameSet(j, userInput).fullName;
                
                babyNames.push({
                  fullName: defaultName,
                  gender: gender,
                  babyIndex: j
                });
              }
            }
          } else {
            // 尝试从单个名字对象提取名字信息
            const namesList = [];
            
            // 检查是否有name数组
            if (nameData.names && Array.isArray(nameData.names)) {
              for (let j = 0; j < nameData.names.length && j < userInput.multipleCount; j++) {
                const nameEntry = nameData.names[j];
                if (typeof nameEntry === 'string') {
                  namesList.push(nameEntry);
                } else if (nameEntry && nameEntry.name) {
                  namesList.push(nameEntry.name);
                }
              }
            } else if (nameData.name && typeof nameData.name === 'string') {
              // 如果有单个名字，尝试按逗号或其他分隔符拆分
              const namesParts = nameData.name.split(/[,，、]/);
              for (let part of namesParts) {
                if (part.trim()) {
                  namesList.push(part.trim());
                }
              }
            }
            
            // 使用提取的名字或生成默认名
            for (let j = 0; j < userInput.multipleCount; j++) {
              const gender = userInput.genders[j] || '男';
              let fullName;
              
              if (j < namesList.length && namesList[j]) {
                fullName = namesList[j].startsWith(userInput.surname) ? 
                  namesList[j] : 
                  userInput.surname + namesList[j];
              } else {
                fullName = this.generateDefaultNameSet(j, userInput).fullName;
              }
              
              babyNames.push({
                fullName: fullName,
                gender: gender,
                babyIndex: j
              });
            }
          }
        } else {
          // 单胎场景
          let fullName = '';
          if (nameData.fullName) {
            fullName = nameData.fullName;
          } else if (nameData.name) {
            fullName = typeof nameData.name === 'string' ? nameData.name : '';
          } else if (nameData.fullNames && Array.isArray(nameData.fullNames) && nameData.fullNames.length > 0) {
            const nameEntry = nameData.fullNames[0];
            if (typeof nameEntry === 'string') {
              fullName = nameEntry;
            } else if (nameEntry) {
              fullName = nameEntry.fullName || nameEntry.name || '';
            }
          } else {
            // 默认名
            fullName = this.generateDefaultNameSet(0, userInput).fullName;
          }
          
          // 确保姓氏正确
          if (!fullName.startsWith(userInput.surname)) {
            fullName = userInput.surname + fullName;
          }
          
          babyNames.push({
            fullName: fullName,
            gender: userInput.genders[0] || '男',
            babyIndex: 0
          });
        }
        
        // 构建名字组对象
        names.push({
          fullNames: babyNames,
          meaning: nameData.meaning || '暂无解释',
          relationMeaning: nameData.relationMeaning || 
                          (userInput.isMultipleBirth ? '名字间有良好的联系' : ''),
          wuxing: nameData.wuxing || nameData.fiveElements || '五行匹配',
          zodiac: nameData.zodiac || '与生肖相配',
          phonetics: nameData.phonetics || nameData.sound || '音韵和谐',
          structure: nameData.structure || '结构稳健'
        });
        
        console.log(`添加名字组[${i}]，包含${babyNames.length}个名字`);
      }
      
      // 确保返回足够数量的名字卡片
      while (names.length < 10) {
        const babyNames = [];
        
        // 为每个宝宝创建默认名
        if (userInput.isMultipleBirth) {
          for (let j = 0; j < userInput.multipleCount; j++) {
            const defaultNameObj = this.generateDefaultNameSet(j, userInput, names.length);
            
            babyNames.push({
              fullName: defaultNameObj.fullName,
              gender: defaultNameObj.gender,
              babyIndex: j
            });
          }
        } else {
          const defaultNameObj = this.generateDefaultNameSet(0, userInput, names.length);
          
          babyNames.push({
            fullName: defaultNameObj.fullName,
            gender: defaultNameObj.gender,
            babyIndex: 0
          });
        }
        
        names.push({
          fullNames: babyNames,
          meaning: '系统默认名字',
          relationMeaning: userInput.isMultipleBirth ? '名字间保持良好的联系' : '',
          wuxing: '五行匹配',
          zodiac: '与生肖相配',
          phonetics: '音韵和谐',
          structure: '结构稳健'
        });
        
        console.log(`添加默认名字组[${names.length-1}]，包含${babyNames.length}个名字`);
      }
      
      console.log('格式化完成，共处理名字数量:', names.length);
      return names;
    } catch (error) {
      console.error('格式化AI响应时出错:', error);
      // 发生错误时使用本地生成的备用名字
      return this.generateFallbackNames(userInput);
    }
  },
  
  // 生成备用名字列表
  generateFallbackNames(userInput) {
    console.log('使用备用名字生成方法')
    try {
      return this.generateNamesLocally(userInput)
    } catch (fallbackError) {
      console.error('备用名字生成也失败:', fallbackError)
      
      // 提供最基本的默认名字列表
      const names = []
      const count = userInput.isMultipleBirth ? userInput.multipleCount : 1
      const nameLength = userInput.nameLength || '2' // 获取名字长度参数，默认两字
      // 根据性别和名字长度选择不同的默认名
      const getDefaultName = (gender, index) => {
        if (gender === '男') {
          return nameLength === '3' ? 
            `${userInput.surname}子健${index}` : 
            `${userInput.surname}子${index}`
        } else {
          return nameLength === '3' ? 
            `${userInput.surname}美丽${index}` : 
            `${userInput.surname}美${index}`
        }
      }
      
      for (let i = 0; i < 10; i++) {
        const babyNames = []
        
        for (let j = 0; j < count; j++) {
          const gender = userInput.genders[j] || '男'
          const defaultName = getDefaultName(gender, i+1)
          babyNames.push({
            fullName: defaultName,
            gender: gender,
            babyIndex: j
          })
        }
        
        names.push({
          fullNames: babyNames,
          meaning: '系统默认名字',
          relationMeaning: '',
          wuxing: '五行匹配',
          zodiac: '与生肖相配',
          phonetics: '音韵和谐',
          structure: '结构稳健'
        })
      }
      
      return names
    }
  },
  
  // 生成默认名字集（当AI响应解析失败时使用）
  generateDefaultNameSet(index, userInput) {
    // 不要调用generateNamesLocally，会导致循环引用
    // 使用上面的备用生成方法
    const fallbackNames = this.generateFallbackNames(userInput);
    return fallbackNames[index % fallbackNames.length];
  },

  // 本地生成名字的方法（原有逻辑移至此处）
  generateNamesLocally(userInput) {
      // 返回模拟数据
      const names = []
      const count = userInput.isMultipleBirth ? userInput.multipleCount : 1
    const nameLength = userInput.nameLength || '2' // 获取名字长度参数，默认两字
      
    console.log(`本地生成名字，参数：姓氏=${userInput.surname}, 名字长度=${nameLength}, 多胞胎=${count}`)
    
    // 双胞胎关联名字组合（强关联型）- 两字名
      const twinMaleNames = [
        ['雨', '露'], // 同出自"雨露"，自然现象
        ['诗', '书'], // 同出自"诗书"，文化典籍
        ['德', '才'], // 同出自"德才兼备"
        ['志', '向'], // 同为"志向"一词拆分
        ['文', '武'], // 对应词组"文武双全"
        ['山', '水'], // 同为自然景观"山水"
        ['金', '玉'], // 同为贵重金属"金玉"
        ['阳', '光'], // 同属"阳光"一词
        ['耀', '华'], // 同音字"耀华/曜华"
        ['睿', '智'] // 同属"睿智"一词
      ]
    
    // 三字名 - 双胞胎男孩
    const twinMaleNamesThree = [
      ['雨泽', '露润'], // 同出自"雨露"，自然现象
      ['诗文', '书华'], // 同出自"诗书"，文化典籍
      ['德行', '才华'], // 同出自"德才兼备"
      ['志远', '向宏'], // 同为"志向"一词拆分
      ['文韬', '武略'], // 对应词组"文武双全"
      ['山岳', '水润'], // 同为自然景观"山水"
      ['金辉', '玉宇'], // 同为贵重金属"金玉"
      ['阳朗', '光辉'], // 同属"阳光"一词
      ['耀辉', '华彦'], // 同音字"耀华/曜华"
      ['睿志', '智远'] // 同属"睿智"一词
    ]
      
      const twinFemaleNames = [
        ['思', '念'], // 同出自"思念"一词
        ['芳', '华'], // 同出自"芳华"，指美好年华
        ['琴', '瑟'], // 同为古代乐器，琴瑟和鸣
        ['诗', '韵'], // 同为诗词领域
        ['花', '蕾'], // 同为"花蕾"，植物意象
        ['婉', '约'], // 同出自"婉约"，形容气质
        ['彩', '云'], // 同出自"彩云"，自然意象
        ['芙', '蓉'], // 同为"芙蓉"，植物名
        ['玉', '珍'], // 同为珍贵之物
        ['嫣', '然'] // 同出自"嫣然一笑"
      ]
      
    // 三字名 - 双胞胎女孩
    const twinFemaleNamesThree = [
      ['思雅', '念馨'], // 同出自"思念"一词
      ['芳菲', '华锦'], // 同出自"芳华"，指美好年华
      ['琴音', '瑟韵'], // 同为古代乐器，琴瑟和鸣
      ['诗情', '韵雅'], // 同为诗词领域
      ['花语', '蕾馨'], // 同为"花蕾"，植物意象
      ['婉婷', '约素'], // 同出自"婉约"，形容气质
      ['彩萱', '云霞'], // 同出自"彩云"，自然意象
      ['芙蓉', '蕙兰'], // 同为植物名
      ['玉洁', '珍雅'], // 同为珍贵之物
      ['嫣然', '婷婷'] // 形容气质美好
    ]
    
    // 三胞胎关联名字组合 - 两字名
      const tripletMaleNames = [
        ['松', '竹', '梅'], // 岁寒三友
        ['天', '地', '人'], // 天地人三才
        ['金', '木', '水'], // 五行元素
        ['智', '仁', '勇'], // 智仁勇三达德
        ['家', '国', '天'] // 家国天下
      ]
      
      const tripletFemaleNames = [
        ['春', '夏', '秋'], // 四季(缺冬)
        ['梅', '兰', '竹'], // 梅兰竹菊(缺菊)
        ['琴', '棋', '书'], // 琴棋书画(缺画)
        ['红', '绿', '蓝'], // 三原色
        ['清', '雅', '丽'] // 形容词组合
      ]
      
    // 三胞胎关联名字组合 - 三字名
    const tripletMaleNamesThree = [
      ['松柏', '竹青', '梅香'], // 岁寒三友
      ['天行', '地载', '人和'], // 天地人三才
      ['金辉', '木秀', '水灵'], // 五行元素
      ['智睿', '仁厚', '勇毅'], // 智仁勇三达德
      ['家和', '国强', '天佑'] // 家国天下
    ]
    
    const tripletFemaleNamesThree = [
      ['春晖', '夏荷', '秋菊'], // 四季(缺冬)
      ['梅韵', '兰馨', '竹影'], // 梅兰竹菊(缺菊)
      ['琴瑟', '棋艺', '书香'], // 琴棋书画(缺画)
      ['红霞', '绿萝', '蓝波'], // 三原色
      ['清馨', '雅韵', '丽影'] // 形容词组合
    ]
    
    // 四胞胎关联名字组合 - 两字名
      const quadrupletMaleNames = [
        ['春', '夏', '秋', '冬'], // 四季
        ['东', '西', '南', '北'], // 四方
        ['金', '木', '水', '火'] // 五行(缺土)
      ]
      
      const quadrupletFemaleNames = [
        ['梅', '兰', '竹', '菊'], // 四君子
        ['琴', '棋', '书', '画'], // 四艺
        ['诗', '书', '礼', '乐'] // 四艺
      ]
      
    // 四胞胎关联名字组合 - 三字名
    const quadrupletMaleNamesThree = [
      ['春阳', '夏荷', '秋月', '冬雪'], // 四季
      ['东旭', '西峰', '南风', '北辰'], // 四方
      ['金辉', '木华', '水润', '火炬'] // 五行(缺土)
    ]
    
    const quadrupletFemaleNamesThree = [
      ['梅韵', '兰馨', '竹雅', '菊香'], // 四君子
      ['琴音', '棋艺', '书香', '画意'], // 四艺
      ['诗情', '书韵', '礼仪', '乐章'] // 四艺
    ]
    
    // 五胞胎关联名字组合 - 两字名
      const quintupletMaleNames = [
        ['金', '木', '水', '火', '土'], // 五行
        ['仁', '义', '礼', '智', '信'] // 五常
      ]
      
      const quintupletFemaleNames = [
        ['梅', '竹', '松', '菊', '莲'], // 五种传统名花
        ['红', '橙', '黄', '绿', '蓝'] // 五彩
      ]
      
    // 五胞胎关联名字组合 - 三字名
    const quintupletMaleNamesThree = [
      ['金辉', '木秀', '水灵', '火炬', '土壤'], // 五行
      ['仁厚', '义方', '礼仪', '智慧', '信诚'] // 五常
    ]
    
    const quintupletFemaleNamesThree = [
      ['梅馨', '竹影', '松涛', '菊韵', '莲清'], // 五种传统名花
      ['红霞', '橙晖', '黄华', '绿萝', '蓝波'] // 五彩
    ]
    
    // 单胎时使用的名字列表 - 两字名
      const singleMaleNames = [
      ['浩然'], ['宇轩'], ['子墨'], ['天成'], ['博文'], 
      ['睿轩'], ['梓辰'], ['晨曦'], ['远航'], ['泽宇']
      ]
      
      const singleFemaleNames = [
      ['雅萱'], ['梦琪'], ['语嫣'], ['芷若'], ['清雅'], 
      ['诗涵'], ['倪瑶'], ['若溪'], ['璎珞'], ['思怡']
    ]
    
    // 单胎三字名
    const singleMaleNamesThree = [
      ['浩然之'], ['宇轩辰'], ['子墨凡'], ['天成志'], ['博文韬'], 
      ['睿智远'], ['梓辰宇'], ['晨曦阳'], ['远航帆'], ['泽宇翔']
    ]
    
    const singleFemaleNamesThree = [
      ['雅萱婷'], ['梦琪瑶'], ['语嫣然'], ['芷若馨'], ['清雅菲'], 
      ['诗涵雅'], ['倪瑶琳'], ['若溪柔'], ['璎珞雅'], ['思怡婉']
      ]

      // 普通名字特点描述
      const meanings = {
        male: [
          '才华横溢，志向远大',
          '聪明睿智，胸怀宽广',
          '正直诚信，品德高尚',
          '勇敢坚毅，前程似锦',
          '智慧超群，前途光明',
          '慧眼如炬，胆识过人',
          '气宇轩昂，英姿勃发',
          '沉稳大气，刚毅坚定',
          '聪颖睿达，志在千里',
          '才气纵横，勇往直前'
        ],
        female: [
          '温婉淑德，知性优雅',
          '聪慧灵秀，气质非凡',
          '端庄典雅，才艺双全',
          '清丽脱俗，品性高洁',
          '温柔贤淑，才情兼备',
          '秀外慧中，端庄大方',
          '智慧聪颖，风姿绰约',
          '明丽动人，灵秀非凡',
          '娴静淑雅，气度不凡',
          '活泼开朗，阳光睿智'
        ]
      }
      
      // 强关联名字的关系描述
      const relationMeanings = [
        '出自同一成语或词组，意境连贯完整',
        '同为传统文化典故，互相呼应',
        '出自古代经典著作或诗文，寓意深远',
        '同为自然景物或意象，相互映衬',
        '均取自传统美德或价值观念，内涵丰富',
        '源自同一古诗词名句，典雅文化',
        '同为传统文化元素，寓意吉祥',
        '同韵同声，读音协调，朗朗上口',
        '同属五行学说，增强整体运势',
        '同为传统文化象征，内涵丰富'
      ]

      const wuxings = ['金木水', '木水火', '水土金', '火木土', '土金水', '金水木', '木火金', '水火土', '火土水', '土金木']
      const zodiacs = ['与生肖相配，寓意吉祥', '生肖相合，运势昌隆', '八字相生，前程似锦', '八字形合，大吉大利', '生肖相助，吉祥如意']
      const phonetics = ['声调和谐，朗朗上口', '音律优美，韵味悠长', '读音清亮，余音绕梁', '声韵和美，音韵悠扬', '声调抑扬，韵律优美']
      const structures = ['字形端正，结构匀称', '笔画优美，结构合理', '字形秀丽，结构和谐', '字形秀气，结构稳健', '笔画流畅，结构精美']
      
      // 根据胎数选择合适的名字组合
      function selectNameList(gender, count) {
      const isThreeChars = nameLength === '3';
      
        if (!userInput.isMultipleBirth) {
        if (isThreeChars) {
          return gender === '男' ? singleMaleNamesThree : singleFemaleNamesThree;
        }
        return gender === '男' ? singleMaleNames : singleFemaleNames;
      }
      
      if (count === 2) {
        if (isThreeChars) {
          return gender === '男' ? twinMaleNamesThree : twinFemaleNamesThree;
        }
        return gender === '男' ? twinMaleNames : twinFemaleNames;
      }
      
      // 对于多胞胎，根据数量和名字长度选择合适的名字组合
        switch(count) {
          case 3:
          if (isThreeChars) {
            return gender === '男' ? tripletMaleNamesThree : tripletFemaleNamesThree;
          }
          return gender === '男' ? tripletMaleNames : tripletFemaleNames;
          case 4:
          if (isThreeChars) {
            return gender === '男' ? quadrupletMaleNamesThree : quadrupletFemaleNamesThree;
          }
          return gender === '男' ? quadrupletMaleNames : quadrupletFemaleNames;
          case 5:
          if (isThreeChars) {
            return gender === '男' ? quintupletMaleNamesThree : quintupletFemaleNamesThree;
          }
          return gender === '男' ? quintupletMaleNames : quintupletFemaleNames;
          default:
          if (isThreeChars) {
            return gender === '男' ? twinMaleNamesThree : twinFemaleNamesThree;
          }
          return gender === '男' ? twinMaleNames : twinFemaleNames;
        }
      }
      
      // 为多胞胎生成10个名字卡片推荐
      for (let i = 0; i < 10; i++) {
        const babyNames = []
        const baseMeaningList = []
        
        // 为每个宝宝生成关联名字
        for (let j = 0; j < count; j++) {
          const gender = userInput.genders[j]
          const nameList = selectNameList(gender, count)
          const meaningList = gender === '男' ? meanings.male : meanings.female
          
          // 使用i作为索引来选择同一组关联名字
          const nameIndex = i % nameList.length
          
        // 检查索引是否有效，防止数组越界
        if (nameList[nameIndex] && j < nameList[nameIndex].length) {
          // 构建单个宝宝的名字对象
          babyNames.push({
            name: nameList[nameIndex][j],
            gender: gender
          })
        } else {
          // 如果索引无效，使用备用名
          const backupName = gender === '男' ? 
            (nameLength === '3' ? '浩然之' : '浩然') : 
            (nameLength === '3' ? '雅萱婷' : '雅萱');
          
          console.warn(`名字组合索引无效: nameList[${nameIndex}][${j}]，使用备用名: ${backupName}`)
          babyNames.push({
            name: backupName,
            gender: gender
          })
        }
          
          // 收集每个宝宝的基础含义描述
          baseMeaningList.push(meaningList[j % meaningList.length])
        }
        
        // 确定关联类型的描述
        let relationType = ''
        if (count > 1) {
          const nameIndex = i % twinMaleNames.length
          if (count === 2) {
            // 为双胞胎添加具体的关联说明
            if (userInput.genders[0] === '男' && userInput.genders[1] === '男') {
              // 根据实际名字组合添加解释
              switch(nameIndex) {
                case 0: relationType = '取自"雨露"，象征恩泽、滋养'; break;
                case 1: relationType = '取自"诗书"，象征才学文化'; break;
                case 2: relationType = '取自"德才兼备"，寓意品德才华俱佳'; break;
                case 3: relationType = '来自"志向"一词，表达理想抱负'; break;
                case 4: relationType = '取自"文武双全"，象征全面发展'; break;
                case 5: relationType = '取自"山水"，象征人与自然和谐'; break;
                case 6: relationType = '取自"金玉良言"，象征珍贵'; break;
                case 7: relationType = '取自"阳光"，象征温暖朝气'; break;
                case 8: relationType = '同音"耀华/曜华"，象征光明灿烂'; break;
                case 9: relationType = '取自"睿智"，象征聪明智慧'; break;
              }
            } else if (userInput.genders[0] === '女' && userInput.genders[1] === '女') {
              switch(nameIndex) {
                case 0: relationType = '取自"思念"，意蕴深远温柔'; break;
                case 1: relationType = '取自"芳华"，象征美好年华'; break;
                case 2: relationType = '取自"琴瑟和鸣"，象征和谐'; break;
                case 3: relationType = '取自"诗韵"，意境优美'; break;
                case 4: relationType = '取自"花蕾"，寓意绽放之美'; break;
                case 5: relationType = '取自"婉约"，形容温婉典雅'; break;
                case 6: relationType = '取自"彩云"，象征美好吉祥'; break;
                case 7: relationType = '取自"芙蓉"，象征纯洁之美'; break;
                case 8: relationType = '取自"玉珍"，象征珍贵高洁'; break;
                case 9: relationType = '取自"嫣然一笑"，形容笑容之美'; break;
              }
            } else {
              relationType = relationMeanings[i % relationMeanings.length];
            }
          } else if (count === 3) {
            // 为三胞胎添加具体说明
            if (userInput.genders.every(g => g === '男')) {
              switch(nameIndex % tripletMaleNames.length) {
                case 0: relationType = '取自"岁寒三友"，象征坚韧品格'; break;
                case 1: relationType = '取自"天地人"三才，象征和谐统一'; break;
                case 2: relationType = '取自五行元素，象征相生相克的平衡'; break;
                case 3: relationType = '取自"智仁勇"三达德，源自《论语》'; break;
                case 4: relationType = '取自"家国天下"，象征胸怀壮志'; break;
              }
            } else if (userInput.genders.every(g => g === '女')) {
              switch(nameIndex % tripletFemaleNames.length) {
                case 0: relationType = '取自四季(缺冬)，象征生生不息'; break;
                case 1: relationType = '取自"梅兰竹"，象征高雅品格'; break;
                case 2: relationType = '取自"琴棋书"艺术，象征才艺'; break;
                case 3: relationType = '取自三原色，象征多彩人生'; break;
                case 4: relationType = '取自"清雅丽"，象征品质与气质'; break;
              }
            } else {
              relationType = relationMeanings[i % relationMeanings.length];
            }
          } else {
            // 四胞胎和五胞胎使用通用描述
            relationType = relationMeanings[i % relationMeanings.length];
          }
        }
        
        // 构建整个名字卡片对象
        names.push({
          fullNames: babyNames.map((baby, index) => ({
          fullName: userInput.surname + baby.name,
            gender: baby.gender,
            babyIndex: index
          })),
          meaning: baseMeaningList.join('\n'),
          relationMeaning: count > 1 ? (relationType || relationMeanings[i % relationMeanings.length]) : '',
          wuxing: wuxings[i % wuxings.length],
          zodiac: zodiacs[i % zodiacs.length],
          phonetics: phonetics[i % phonetics.length],
          structure: structures[i % structures.length]
        })
      }
      
    console.log(`本地生成名字完成，共生成${names.length}组名字`)
      return names
  },

  buildPrompt(userInput) {
    const {
      birthDate,
      birthTime,
      isMultipleBirth,
      multipleCount,
      genders,
      surname,
      avoidWords,
      nameLength
    } = userInput

    return `请根据以下信息生成10组中文名字推荐，每组包含${isMultipleBirth ? multipleCount : 1}个名字：
    姓氏：${surname}
    出生日期：${birthDate}
    出生时辰：${birthTime || '未知'}
    性别：${genders.join(', ')}
    需要避开的字：${avoidWords || '无'}
    名字长度：${nameLength || '2'}字
    ${isMultipleBirth ? `多胞胎数量：${multipleCount}` : ''}
    
    请考虑以下因素：
    1. 五行分析
    2. 生肖分析
    3. 音韵美感
    4. 字形搭配
    5. 性别特征
    ${isMultipleBirth ? '6. 名字之间的关联性和谐性' : ''}
    
    请以JSON格式返回结果，每组名字包括：
    {
      "fullNames": [{"fullName": "完整姓名", "gender": "性别", "babyIndex": 序号}],
      "meaning": "名字含义",
      "relationMeaning": "关联含义说明(多胞胎时)",
      "wuxing": "五行属性",
      "zodiac": "生肖搭配",
      "phonetics": "音韵分析",
      "structure": "字形分析"
    }`
  },

  // 解析AI返回的响应文本
  parseResponse(responseText) {
    console.log('开始解析AI响应:', typeof responseText)
    
    try {
      // 如果响应已经是一个对象，尝试直接使用
      if (typeof responseText === 'object') {
        // 检查是否是Axios响应对象
        if (responseText.data) {
          console.log('响应是Axios对象，提取data')
          responseText = responseText.data
        }
        
        // 如果是空对象，返回null
        if (Object.keys(responseText).length === 0) {
          console.error('响应是空对象')
          return null
        }
        
        // 如果响应包含choices字段(OpenAI格式)，尝试提取内容
        if (responseText.choices && Array.isArray(responseText.choices) && responseText.choices.length > 0) {
          console.log('检测到OpenAI API格式响应')
          
          // 获取消息内容
          const message = responseText.choices[0].message
          
          if (message && message.content) {
            console.log('从OpenAI响应中提取content')
            responseText = message.content
          }
        }
      }
      
      // 确保响应是字符串
      let jsonStr = typeof responseText === 'string' ? responseText : JSON.stringify(responseText)
      
      // 处理可能的代码块格式 (```json ... ```)
      const codeBlockMatch = jsonStr.match(/```(?:json)?\s*([\s\S]*?)\s*```/)
      if (codeBlockMatch && codeBlockMatch[1]) {
        console.log('从代码块中提取JSON')
        jsonStr = codeBlockMatch[1].trim()
      }
      
      // 检查并修复不完整的JSON字符串
      const openBrackets = (jsonStr.match(/\[/g) || []).length
      const closeBrackets = (jsonStr.match(/\]/g) || []).length
      const openCurly = (jsonStr.match(/\{/g) || []).length
      const closeCurly = (jsonStr.match(/\}/g) || []).length
      
      if (openBrackets > closeBrackets || openCurly > closeCurly) {
        console.warn('JSON字符串可能不完整，尝试修复')
        
        // 添加缺失的关闭括号
        while (openCurly > closeCurly) {
          jsonStr += '}'
          closeCurly++
        }
        
        while (openBrackets > closeBrackets) {
          jsonStr += ']'
          closeBrackets++
        }
        
        console.log('修复后的JSON字符串:', jsonStr.substring(0, 100) + '...')
      }
      
      // 尝试解析JSON
      const parsedData = JSON.parse(jsonStr)
      
      // 如果解析后是空对象，返回null
      if (typeof parsedData === 'object' && Object.keys(parsedData).length === 0) {
        console.error('解析后的JSON是空对象')
        return null
      }
      
      return parsedData
    } catch (error) {
      console.error('解析AI响应失败:', error.message)
      return null
    }
  },
  
  // 解析非JSON格式的文本响应
  parseTextResponse(text) {
    // 这里需要实现文本解析逻辑，将AI返回的文本格式转换为应用所需的数据结构
    // 这个实现会比较复杂，依赖于AI实际返回的格式
    // 简单起见，这里返回空数组，实际使用时会回退到本地生成
    console.log('AI返回了非JSON格式的响应，需要解析')
    return []
  },

  // 调用DeepSeek API
  async callDeepSeekAPI(userInput, apiKey) {
    const prompt = this.generateDeepSeekPrompt(userInput);
    
    const apiEndpoint = import.meta.env.VITE_DEEPSEEK_API_URL || 'https://api.deepseek.com/v1/chat/completions';
    const modelName = import.meta.env.VITE_DEEPSEEK_MODEL || 'deepseek-chat';
    
    const requestBody = {
      model: modelName,
      messages: [
        {
          role: 'user',
          content: prompt
        }
      ],
      temperature: 0.7,
      max_tokens: 3600
    };
    
    return fetch(apiEndpoint, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${apiKey}`
      },
      body: JSON.stringify(requestBody)
    });
  },
  
  // 统一的提示词生成函数
  generateUnifiedPrompt(userInput) {
    const { gender, births, nameLength, surname, avoidWords, birthDate, birthTime, isMultipleBirth, multipleCount, genders } = userInput;
    
    let promptText = '你是一名专业的中国传统起名专家，精通五行、生肖、诗词、国学等传统文化知识。\n\n';
    
    // 基本信息部分
    promptText += `请为${isMultipleBirth ? `${multipleCount}个` : '一个'}${isMultipleBirth ? '' : this.getGenderText(gender)}婴儿生成${nameLength === '3' ? '三个字' : '两个字'}的中文名字，包含姓氏，共10组。\n\n`;
    
    // 详细要求
    promptText += '详细信息如下：\n';
    promptText += `姓氏：${surname}\n`;
    
    if (birthDate) {
      promptText += `出生日期：${birthDate}\n`;
    }
    
    if (birthTime) {
      promptText += `出生时辰：${birthTime}\n`;
    }
    
    // 性别信息
    if (isMultipleBirth) {
      promptText += '宝宝性别：\n';
      for (let i = 0; i < multipleCount; i++) {
        promptText += `- 宝宝${i+1}：${genders[i] || '未指定'}\n`;
      }
    } else {
      promptText += `性别：${gender === 'male' ? '男' : '女'}\n`;
    }
    
    if (avoidWords && avoidWords.trim() !== '') {
      promptText += `需要避开的字：${avoidWords}\n`;
    }
    
    // 多胞胎关联性要求
    if (isMultipleBirth && multipleCount > 1) {
      promptText += '\n【多胞胎名字要求】\n';
      promptText += '由于是多胞胎，请确保生成的名字之间有强关联性，可以考虑：\n';
      promptText += '1. 出自同一成语或典故的名字\n';
      promptText += '2. 具有相同韵律或音韵的名字\n';
      promptText += '3. 意境相近或相互呼应的名字\n';
      promptText += '4. 五行相生相配的名字\n';
      
      // 针对不同多胞胎数量的特殊建议
      if (multipleCount === 2) {
        promptText += '适合双胞胎的名字组合如：【诗、书】、【山、水】、【金、玉】等\n';
      } else if (multipleCount === 3) {
        promptText += '适合三胞胎的名字组合如：【松、竹、梅】(岁寒三友)、【天、地、人】(三才)等\n';
      } else if (multipleCount === 4) {
        promptText += '适合四胞胎的名字组合如：【春、夏、秋、冬】(四季)、【梅、兰、竹、菊】(四君子)等\n';
      } else if (multipleCount === 5) {
        promptText += '适合五胞胎的名字组合如：【金、木、水、火、土】(五行)、【仁、义、礼、智、信】(五常)等\n';
      }
    }
    
    // 返回格式要求
    promptText += '\n【返回格式】\n';
    promptText += '请严格按照以下JSON格式返回，不要添加其他解释文字：\n';
    promptText += '[\n';
    
    if (isMultipleBirth) {
      promptText += '  {\n';
      promptText += '    "fullNames": [\n';
      for (let i = 0; i < multipleCount; i++) {
        promptText += `      {"name": "宝宝${i+1}的名(不含姓氏)", "gender": "${genders[i] || '未指定'}"}${i < multipleCount-1 ? ',' : ''}\n`;
      }
      promptText += '    ],\n';
      promptText += '    "meaning": "整组名字的含义解释",\n';
      promptText += '    "relationMeaning": "名字间的关联性解释",\n';
      promptText += '    "wuxing": "五行分析",\n';
      promptText += '    "zodiac": "生肖分析",\n';
      promptText += '    "phonetics": "音韵分析",\n';
      promptText += '    "structure": "结构分析"\n';
      promptText += '  },\n';
      promptText += '  ...(共生成10组相关联的名字)\n';
    } else {
      promptText += '  {\n';
      promptText += '    "name": "名字1(不含姓氏)",\n';
      promptText += '    "meaning": "名字含义详细解释"\n';
      promptText += '  },\n';
      promptText += '  ...(共生成10个名字)\n';
    }
    
    promptText += ']\n\n';
    
    // 强调名字长度
    promptText += `请确保每个名字的长度为${nameLength === '3' ? '三' : '二'}个字，包含姓氏。`;
    
    return promptText;
  },

  // 为DeepSeek模型生成提示词
  generateDeepSeekPrompt(userInput) {
    return this.generateUnifiedPrompt(userInput);
  },
  
  // 为火山大模型生成提示词
  generateVolcanoPrompt(userInput) {
    return this.generateUnifiedPrompt(userInput);
  },

  // 获取性别文本描述
  getGenderText(gender) {
    return gender === 'male' ? '男' : '女';
  },
  
  // 获取出生数量文本描述
  getBirthsText(births) {
    switch(parseInt(births)) {
      case 2:
        return '双胞胎';
      case 3:
        return '三胞胎';
      case 4:
        return '四胞胎';
      case 5:
        return '五胞胎';
      default:
        return '单个婴儿';
    }
  },

  // 通用的大模型响应解析函数
  parseModelResponse(responseData, modelType) {
    try {
      console.log(`解析${modelType}模型响应数据`);
      
      if (!responseData) {
        console.error('响应数据为空');
        return [];
      }
      
      // 根据模型类型选择解析函数
      switch(modelType) {
        case 'volcano':
          return this.parseVolcanoResponse(responseData);
        case 'deepseek':
          return this.parseDeepSeekResponse(responseData);
        default:
          console.warn(`未知的模型类型: ${modelType}，尝试通用解析`);
          // 尝试通用解析
          return this.parseGenericLLMResponse(responseData);
      }
    } catch (error) {
      console.error(`解析${modelType}模型响应出错:`, error);
      return [];
    }
  },
  
  // 通用LLM响应解析，用于处理未知模型类型
  parseGenericLLMResponse(responseData) {
    console.log('解析通用LLM响应:', typeof responseData);
    if (!responseData) {
      console.error('响应数据为空');
      return [];
    }
    
    try {
      let content = '';
      
      // 如果是字符串，直接使用
      if (typeof responseData === 'string') {
        content = responseData;
      }
      // 检查OpenAI兼容格式
      else if (responseData.choices && responseData.choices.length > 0) {
        if (responseData.choices[0].message && responseData.choices[0].message.content) {
          content = responseData.choices[0].message.content;
        } else if (responseData.choices[0].text) {
          content = responseData.choices[0].text;
        }
      }
      // 其他可能的格式
      else if (responseData.response) {
        content = responseData.response;
      } else if (responseData.content) {
        content = responseData.content;
      } else if (responseData.text) {
        content = responseData.text;
      } else {
        // 如果找不到已知格式，尝试转换整个对象
        content = JSON.stringify(responseData);
      }
      
      console.log(`提取的内容长度: ${content.length} 字符`);
      
      // 尝试直接解析JSON
      try {
        const parsedData = JSON.parse(content);
        console.log('成功直接解析JSON');
        
        // 检查是否是数组
        if (Array.isArray(parsedData)) {
          return parsedData;
        }
        
        // 检查是否包含fullNames属性
        if (parsedData.fullNames) {
          return [parsedData];
        }
        
        // 如果是其他格式，尝试转换
        console.warn('JSON格式不是预期的姓名列表');
        return [];
      } catch (parseError) {
        console.warn('直接解析JSON失败，尝试修复或提取:', parseError.message);
        
        // 尝试修复不完整的JSON
        const fixedContent = this.repairIncompleteJson(content);
        try {
          const parsedData = JSON.parse(fixedContent);
          console.log('修复后成功解析JSON');
          
          if (Array.isArray(parsedData)) {
            return parsedData;
          }
          
          if (parsedData.fullNames) {
            return [parsedData];
          }
        } catch (fixError) {
          console.warn('修复后仍然无法解析JSON:', fixError.message);
        }
        
        // 尝试提取JSON对象
        const extractedObjects = this.extractJsonObjects(content);
        if (extractedObjects.length > 0) {
          console.log('成功提取JSON对象:', extractedObjects.length);
          return extractedObjects;
        }
        
        console.error('无法从响应中提取有效数据');
        return [];
      }
    } catch (error) {
      console.error('解析通用LLM响应出错:', error);
      return [];
    }
  }
};

// 这里不需要重复导出